package com.pactera.service;

import java.util.*;

import org.apache.log4j.Logger;

import com.pactera.cache.Cache;
import com.pactera.consts.Const;
import com.pactera.pojo.CmrAjf;
import com.pactera.pojo.SmsLog;
import com.pactera.pojo.SmsPhone;
import com.pactera.utils.DateUtil;

public class TimerService {

	private static Logger logger = Logger.getLogger(TimerService.class);
	private JobService jobService = new JobService();
	private PostgresDBService postgresService = new PostgresDBService();
	private OracleDBService oracleService = new OracleDBService();

	// 初始化类型1，防止重复启动程序重复发送
	public void initType1() {
		logger.info("初始化type1,判断标准为有作业错误,发短信");
		// 获取上次发送的短信存入缓存
		List<SmsLog> loglist = oracleService.getLastType1();
		if (loglist == null || loglist.size() == 0){
			
		}else{
			List<CmrAjf> cmrlist = new ArrayList<CmrAjf>();
			String jobname = loglist.get(0).getJobName();
			String sendtime = loglist.get(0).getSendTime();
			String jobnames[] = jobname.split("\\,");
			for (int i = 0; i < jobnames.length; i++) {
				CmrAjf cmrAjf = new CmrAjf(jobnames[i].split("\\.")[0],
						jobnames[i].split("\\.")[1], sendtime.substring(0, 10).replaceAll("-", ""));
				cmrlist.add(cmrAjf);
			}
			Cache.EverSmslist = cmrlist;
		}
		doType1Task();
	}

	// 初始化类型2，获取今天需要执行的程序执行
	public void initType2() {
		logger.info("初始化type2,判断标准为指定作业到规定时间没跑完,发短信");
		// 获取上次发送的短信存入缓存
		List<SmsPhone> list = oracleService.getTodayType2(DateUtil.DateToStr(
				new Date(), "HHmm"));
		for (int i = 0; i < list.size(); i++) {
			if (list.get(i).getQuart_time() != null && list.get(i).getJob_name() != null) {
				Timer timer = doType2Task(list.get(i),DateUtil.getHouraddDay(new Date(), list.get(i).getQuart_time().substring(0, 2),
						list.get(i).getQuart_time().substring(2, 4), 0));
				Cache.timerlist.add(timer);
			}
		}
	}
	// 初始化类型3，防止重复启动程序重复发送
	public void initType3() {
		logger.info("初始化type3,判断标准为job跑完发短信");
		// 获取上次发送的短信存入缓存
		List<SmsLog> loglist = oracleService.getTodayType3();
		if (loglist != null || loglist.size() != 0){
//			return;
            for(SmsLog smslog : loglist){
                String[] names = smslog.getJobName().split("\\,");
                for(int i =0;i<names.length;i++){
                    Cache.type3list.add(names[i]);
                }
            }
        }
		//type3
		logger.info("----开始获取type3作业----"+ DateUtil.DateToStr(new Date()));
		List<SmsPhone> smsPhoneList = oracleService.getSmsPhone(Const.SMS_TYPE_3);
		//type3只有一条配置，jobname有多条
		for(int i=0;i<smsPhoneList.size();i++){
			Timer timer3 = doType3Task(smsPhoneList.get(i));
			Cache.timerlist.add(timer3);
		}

	}

	// 初始化类型4，防止重复启动程序重复发送
	public void initType4() {
		logger.info("初始化type4, 判断标准为整个组跑完,发送短信");
		// 获取上次type4发送的短信日志内容存入缓存
		List<SmsLog> loglist = oracleService.getTodayType4();
		if (loglist != null || loglist.size() != 0){
            for(SmsLog smslog : loglist){
                //不拆分
                Cache.type4list.add(smslog.getJobName());
            }
        }
		//type4
		logger.info("----开始获取type4作业----"+ DateUtil.DateToStr(new Date()));
		List<SmsPhone> smsPhoneList = oracleService.getSmsPhone(Const.SMS_TYPE_4);
		//type4有多条配置(区别在电话和组名)，jobname中可有多条
		for(int i=0;i<smsPhoneList.size();i++){
			Timer timer4 = doType4Task(smsPhoneList.get(i));
			Cache.timerlist.add(timer4);
		}
	}

	//初始化类型6，防止重复启动程序重复发送
	public void initType6() {
		logger.info("初始化type6, 判断标准为所有作业状态为ok,发送短信");
		// 获取上次type6发送的短信日志内容存入缓存
		List<SmsLog> loglist = oracleService.getTodayType6();
		if (loglist != null || loglist.size() != 0){
			//将type6的发送状态放进缓存, 日志loglist不为空， 表明今天已经发送过了
			Cache.isSend = true;
		}else {
			Cache.isSend = false;
		}
		//type6
		logger.info("----开始获取type6配置----"+ DateUtil.DateToStr(new Date()));
		List<SmsPhone> smsPhoneList = oracleService.getSmsPhone(Const.SMS_TYPE_6);
		if(smsPhoneList != null || smsPhoneList.size() != 0){
			Timer timer6 = doType6Task(smsPhoneList.get(0));
			Cache.timerlist.add(timer6);
		}

	}



	// 类型1，循环监控所有作业，如果失败就发短信
	public Timer doType1Task() {
		Timer timer = new Timer();
		timer.schedule(new TimerTask() {
			public void run() {
				logger.info("----type1开始循环监测失败作业----"+ DateUtil.DateToStr(new Date()));
				jobService.doErrorTask(postgresService, oracleService);
			}
		}, 1000, Const.TYPE1_QUART);
		return timer;
	}

	// 每天晚上0点运行，查询需要监测的作业和时间，创建定时程序
	public void doEverydayTask() {
		Timer timer = new Timer();
		/*
		 * Timer.schedule(TimerTask task,Date firstTime ,long period)安排指定的任务在指定的时间开始进行重复的固定延迟执行．
		 */
		timer.schedule(new TimerTask() {
			public void run() {
				// 清空缓存
				for (Timer timer : Cache.timerlist) {
					timer.cancel();
				}
				Cache.timerlist = new ArrayList<Timer>();
				Cache.type3list = new ArrayList<String>();
                Cache.type4list = new ArrayList<String>();
				Cache.isSend = false;
				//type2
				logger.info("----开始获取type2作业----"+ DateUtil.DateToStr(new Date()));
				List<SmsPhone> smsPhoneList = oracleService.getSmsPhone(Const.SMS_TYPE_2);
				for (int i = 0; i < smsPhoneList.size(); i++) {
					if (smsPhoneList.get(i).getQuart_time() != null&& smsPhoneList.get(i).getJob_name() != null) {
						Timer timer2 = doType2Task(smsPhoneList.get(i),DateUtil.getHouraddDay(new Date(), smsPhoneList.get(i).getQuart_time().substring(0, 2),
								smsPhoneList.get(i).getQuart_time().substring(2, 4), 0));
						Cache.timerlist.add(timer2);
					}
				}
				//type3
				logger.info("----开始获取type3作业----"+ DateUtil.DateToStr(new Date()));
				smsPhoneList = oracleService.getSmsPhone(Const.SMS_TYPE_3);
				//type3，jobname有多条
				for(int i=0;i<smsPhoneList.size();i++){
					Timer timer3 = doType3Task(smsPhoneList.get(i));
					Cache.timerlist.add(timer3);
				}

                //type4
                logger.info("----开始获取type4作业----"+ DateUtil.DateToStr(new Date()));
                smsPhoneList = oracleService.getSmsPhone(Const.SMS_TYPE_4);
                //type4，jobname有多条
                for(int i=0;i<smsPhoneList.size();i++){
                    Timer timer4 = doType4Task(smsPhoneList.get(i));
                    Cache.timerlist.add(timer4);
                }

				//type6
				smsPhoneList = oracleService.getSmsPhone(Const.SMS_TYPE_6);
				if(smsPhoneList != null || smsPhoneList.size() != 0){
					Timer timer6 = doType6Task(smsPhoneList.get(0));
					Cache.timerlist.add(timer6);
				}
				
			}
			// 从明天0点开始运行，每24小时执行一次
		}, DateUtil.getHouraddDay(new Date(), "0", "0", 1), Const.EVERYDAY);
//	}, DateUtil.getHouraddDay(new Date(), "10", "42", 0), Const.EVERYDAY);
	}

	// 类型2，如果这些作业到点没有成功，则发送短信
	public Timer doType2Task(final SmsPhone smsPhone,Date date) {
		Timer timer = new Timer();
		/*
		 * 命令说明
		 * timer.schedule(new MyTask(event.getServletContext()), 0, 60*60*1000);
		 * 1. 要做的任务
		 * 2. 0表示无延迟 用户调用 schedule() 方法后，要等待这么长的时间才可以第一次执行 run() 方法
		 * 3. 第一次调用之后，从第二次开始每隔多长的时间调用一次 run() 方法
		 */
		timer.schedule(new TimerTask() {
			public void run() {
				logger.info("--"+DateUtil.DateToStr(new Date())+"--type2开始判断" + smsPhone.getJob_name() + "执行情况----");
				boolean flag = postgresService.isOk(smsPhone.getJob_name());
				if (!flag) {
					// 开始发短信
					logger.info("type2开始发短信,本次发送号码：" + smsPhone.getPhone_number());
					String content = "类型2：作业尚未成功执行："+ DateUtil.DateToStr(new Date(), "MM月dd日HH时mm分")+ smsPhone.getJob_name();
					int result = SmsService.sendSms(Const.SMS_WSDL,Const.SMS_SP_CODE, Const.SMS_USER, Const.SMS_PWD,
							Const.SMS_SI, smsPhone.getPhone_number(), content);
					// 插入日志表
					logger.info("type2开始保存短信日志");
					oracleService.saveSmsLog(smsPhone.getPhone_number(),
							smsPhone.getJob_name(), result,Const.SMS_TYPE_2);
				}
			}
		}, date);
		return timer;
	}

	// 类型6，循环监控类型6要达到的发送条件，如果条件满足就发送短信
	public Timer doType6Task(final SmsPhone smsPhone) {
		Timer timer = new Timer();
		timer.schedule(new TimerTask() {
		   public void run() {
			   logger.info("--"+DateUtil.DateToStr(new Date())+"--type6开始判断 所有作业 目前执行状态----");
			   boolean flag = postgresService.isAllOk();
			   //总作业数和ok作业数相同，且发送标识为false， 才发送短信
			   if(flag&&Cache.isSend==false) {
				   // 开始发短信
				   logger.info("type6(AllJobIsOk)开始发短信,本次发送号码：" + smsPhone.getPhone_number());
				   String content =  DateUtil.DateToStr(new Date(), "MM月dd日HH时mm分") + "类型6：所有作业均已执行成功：";
				   int result = SmsService.sendSms(Const.SMS_WSDL,Const.SMS_SP_CODE, Const.SMS_USER, Const.SMS_PWD,
						   Const.SMS_SI, smsPhone.getPhone_number(), content);
				   // 插入日志表
				   logger.info("type6开始保存短信日志");
				   oracleService.saveSmsLog(smsPhone.getPhone_number(),
						   smsPhone.getJob_name(), result,Const.SMS_TYPE_6);
				   //发送完短信将发送标识置为true
				   Cache.isSend=true;
			   }
		   }
		}, 1000, Const.TYPE6_QUART);
		return timer;
	}


	// 类型3，循环监控配置的作业，如果成功就发送短信
	public Timer doType3Task(final SmsPhone smsPhone) {
		Timer timer = new Timer();
		timer.schedule(new TimerTask() {
			public void run() {
				String jobnames[] = smsPhone.getJob_name().split("\\,");
				List<String> list = Arrays.asList(jobnames);
				List<String> jobnameList = new ArrayList<String>(list);
				//数组没有转成list
				//准备检查的list,跟缓存区别，筛选出没有发送过的
				if(Cache.type3list!=null&&Cache.type3list.size()!=0){
					for(int i=jobnameList.size()-1;i>=0;i--){
						for(int j=0;j<Cache.type3list.size();j++){
							if(jobnameList.get(i).equals(Cache.type3list.get(j))){
								jobnameList.remove(i);
								if(i==0){
									break;
								}
							}
						}
					}
				}
				
				logger.info("--"+DateUtil.DateToStr(new Date())+"--type3开始判断" + smsPhone.getJob_name() + "执行情况----");
				List<String> successList = new ArrayList<String>();
				for(int i=0;i<jobnameList.size();i++){
					boolean flag = postgresService.isOk(jobnameList.get(i));
					if (flag) {
						successList.add(jobnameList.get(i));
					}
				}
				if(successList.size()!=0){
					StringBuffer number = new StringBuffer();
					for(int i=0;i<successList.size();i++){
						number.append(successList.get(i));
						if (i != successList.size() - 1) {
							number.append(",");
						}
					}
					// 开始发短信
					logger.info("type3开始发短信,本次发送号码：" + smsPhone.getPhone_number());
					String content = "类型3：作业:"
							+ number.toString()+"执行成功";
					int result = SmsService.sendSms(Const.SMS_WSDL,
							Const.SMS_SP_CODE, Const.SMS_USER, Const.SMS_PWD,
							Const.SMS_SI, smsPhone.getPhone_number(), content);
					if (result==Const.SMS_SEND_SUCCESS) {
						// 如果成功发送短信，存入缓存防止下次重复发送
						Cache.type3list.addAll(successList);
					}
					// 插入日志表
					logger.info("type3开始保存短信日志");
					oracleService.saveSmsLog(smsPhone.getPhone_number(),
							number.toString(), result,
							Const.SMS_TYPE_3);
				}
			}
		}, 1000, Const.TYPE3_QUART);
		return timer;
	}

	// 类型4，循环监控配置的组作业，如果成功就发送短信
	public Timer doType4Task(final SmsPhone smsPhone) {
		Timer timer = new Timer();
		timer.schedule(new TimerTask() {
			public void run() {
                //将作业组(folder)kdb.sms_phone中一条记录的JOB_NAME,拆分存到一个list中
                //例如: folderNames[] = ELK_SDB,ELK_ODB
				String folderNames[] = smsPhone.getJob_name().split("\\,");
				List<String> list = Arrays.asList(folderNames);
				List<String> folderNameList = new ArrayList<String>(list);
				//数组没有转成list
				//准备检查的list,跟缓存区别，判断此条记录的folder组合是否发送过
				if(Cache.type4list!=null&&Cache.type4list.size()!=0){
						for(int j=0;j<Cache.type4list.size();j++){

                            //比较Cache.type4list中一条记录[get(j)]中的folderName和folderNameList中的folderName是否相同
                            //就是比较两个list中的内容是否相同
                            //相同就把他从folderNameList
                            List<String> type4listRecord = new ArrayList<String>(Arrays.asList(Cache.type4list.get(j).split("\\,")));
                            //排序后比较是否相同
                            Collections.sort(type4listRecord);
                            Collections.sort(folderNameList);
                            //如果相同表明以前发送过,退出此方法
                            if(type4listRecord.equals(folderNameList)){
                                return;
                            }
						}
				}

				logger.info("--"+DateUtil.DateToStr(new Date())+"--type4开始判断" + smsPhone.getJob_name() + "执行情况----");
				List<String> successList = new ArrayList<String>();
                //对没有发送过的folderName组合判断是不是已经运行完,运行完的加到成功list中
                boolean flag = postgresService.groupIsOk(smsPhone.getJob_name());
                if (flag) {
                    successList.add(smsPhone.getJob_name());
                }
				if(successList.size()!=0){
					StringBuffer number = new StringBuffer();
					for(int i=0;i<successList.size();i++){
						number.append(successList.get(i));
						if (i != successList.size() - 1) {
							number.append(",");
						}
					}
					// 开始发短信
					logger.info("type4开始发短信,本次发送号码：" + smsPhone.getPhone_number());
					String content = "类型4：作业组:"
							+ number.toString()+"跑批完成";
					int result = SmsService.sendSms(Const.SMS_WSDL,
							Const.SMS_SP_CODE, Const.SMS_USER, Const.SMS_PWD,
							Const.SMS_SI, smsPhone.getPhone_number(), content);
					if (result==Const.SMS_SEND_SUCCESS) {
						// 如果成功发送短信，存入缓存防止下次重复发送
						Cache.type4list.addAll(successList);
					}
					// 插入日志表
					logger.info("type4开始保存短信日志");
					oracleService.saveSmsLog(smsPhone.getPhone_number(),
							number.toString(), result,
							Const.SMS_TYPE_4);
				}
			}
		}, 1000, Const.TYPE4_QUART);
		return timer;
	}






}
